/* Die Klasse Datentraegersuchen implementiert alle suchemoeglichkeit , 
 * die man fuer die einer Datentraeger braucht
 * 
 * 
 * Datei: Datentraegersuchen.java       
 * BeteiligtePersonen: Gregory Keussi
 * 
 * Datum: 16.11.11                 Version: 0.1 
 * 
 * Historie: 12.11.11 v0.1  
 *                    implementiert  
 * 
 */

package suche;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import medienverwaltung.Datentraeger;
import medienverwaltung.Datentraegertyp;
import medienverwaltung.Medium;
import personenverwaltung.Person;

public class Datentraegersuchen implements SuperString<Medium>
{
  private List<Datentraeger> myDatentraegerList;
  private List<Datentraeger> Ergebnis = new ArrayList<Datentraeger> ();


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach dem Titel
   */

  public List<Datentraeger> suchDatentraegerNachTitel (String titel)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (titel)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach dem Thema
   */
  public List<Datentraeger> suchDatentraegerNachThema (String thema)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (thema)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach der
   * Stichwoerte und liefert eine Liste von entsprechende Datentraegeren
   * zurueck,die Suche Krietere entsprechen
   */

  public List<Datentraeger>
      suchDatentraegerNachStichworte (String stich)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (stich)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach der
   * Fachgebiet und liefert eine Liste von entsprechende Datentraegeren
   * zurueck,die Suche Krietere entsprechen
   */

  public List<Datentraeger>
      suchDatentraegerNachFachgebiet (String fach)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (fach)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach der
   * Initial und liefert eine Liste von entsprechende Datentraegeren
   * zurueck, die Suche Krietere entsprechen
   */

  public List<Datentraeger>
      suchDatentraegerNachInitial (String initial)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (initial)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach der
   * Sachgebiet und liefert eine Liste von entsprechende Datentraegeren
   * zurueck,die Suche Krietere entsprechen
   */

  public List<Datentraeger>
      suchDatentraegerNachSachgebiet (String sach)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibTitel ().contains (sach)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach dem Datum
   * und liefert eine Liste von entsprechende Datentraegeren zurueck,die
   * Suche Krietere entsprechen Die Methode soll auch pruefen, ob das
   * eingegebenen Datum groesser als die Erscheinungsjahr den
   * Datentraegeren ist
   */

  public List<Datentraeger> suchDatentraegerNachErschjahrKlein (
      String date)
  {
    int iDate = Integer.parseInt (date);
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibErscheinungsdatum ().gibJahr () < iDate))
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  public List<Datentraeger> suchDatentraegerNachSchlagworte (
      String schlag)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibStichworte ().contains (schlag)) == true)
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach dem Datum
   * und liefert eine Liste von entsprechende Datentraegeren zurueck,die
   * Suche Krietere entsprechen Die Methode soll auch pruefen, ob das
   * eingegebenen Datum kleiner als die Erscheinungsjahr den
   * Datentraegeren ist
   */

  public List<Datentraeger> suchDatentraegerNachErschjahrGross (
      String date)
  {

    int iDate = Integer.parseInt (date);
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibErscheinungsdatum ().gibJahr () > iDate))
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die suche eines Datentraeger nach dem Datum
   * und liefert eine Liste von entsprechende Datentraegeren zurueck,die
   * Suche Krietere entsprechen Die Methode soll auch pruefen, ob das
   * eingegebenen Datum gleich als die Erscheinungsjahr den
   * Datentraegeren ist
   */

  public List<Datentraeger> suchDatentraegerNachErschjahrGleich (
      String date)
  {

    int iDate = Integer.parseInt (date);
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibErscheinungsdatum ().gibJahr () == iDate))
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methoe ermoeglicht die Recherche von einer Datentraeger nach
   * seinem BeteiligtePersonen. Und liefert eine Liste von
   * Datentraegeren,die den BeteiligtePersonen geschrieben hat.
   */

  public List<Datentraeger> suchDatentraegerNachBeteiligtePersonen (
      String BeteiligtePersonen)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {

      for (Person aut : Datentraeger.gibBeteiligte ())
      {
        if ( (aut.gibNachname ().contains (BeteiligtePersonen)) == true)
        {
          Ergebnis.add (Datentraeger);
        }
      }
    }
    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die Suche einem Datentraeger nach einem
   * Speicherplatz und gibt eine Liste von Datentraeger zurueck
   */

  public List<Datentraeger> suchenDatentraegerNachSpeicherplatz (
      String s)
  {

    int a = Integer.parseInt (s);
    long b = (long) a;
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibSpeicherplatz () == b))
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode ermoeglich die Suche einem Datentraeger nach einem Typ
   * und gibt eine Liste von Datentraeger zurueck
   */

  public List<Datentraeger> suchenDatentraegerNachTyps (
      Datentraegertyp d)
  {
    for (Datentraeger Datentraeger : myDatentraegerList)
    {
      if ( (Datentraeger.gibDatentraegertyp () == d))
      {
        Ergebnis.add (Datentraeger);
      }
    }

    Collections.sort (Ergebnis, new CompareMedium ());
    return Ergebnis;
  }


  /*
   * Die Methode liefert eine Liste von allen Datentraeger, die in der
   * Medienliste sind
   */

  public List<Datentraeger> gibMyDatentraegerList ()
  {
    return myDatentraegerList;
  }


  /*
   * Die Methode ermoeglicht, dass man eine neue Liste von von
   * Datentraeger gibt
   */

  public void setzeMyDatentraegerList (
      List<Datentraeger> myDatentraegerList)
  {
    this.myDatentraegerList = myDatentraegerList;
  }


  /*
   * Die methode liefert eine Liste zurueck. Durch diese Methode kann
   * man eine Liste von seiner gesuchten krietere bekommen
   */

  public List<Datentraeger> gibErgebnis ()
  {
    return Ergebnis;
  }


  /*
   * Die Methode implementiert die Verwaltung von der Suche einer
   * Datentraeger. und sie liefert nichts zurueck
   */

  public void DatentraegerSuchVerwalter (int i, String s)
  {
    switch (i)
    {
    /*
     * Die case 0 ist die zuweisung der werte null an die Liste Ergebnis
     * ,
     */

    case 0:
      Ergebnis = null;
      break;

    /*
     * Die case 1 Aufruf die Methode ,die einen Datentraeger nach
     * beteiligte person sucht.
     */

    case 1:
      suchDatentraegerNachBeteiligtePersonen (s);
      break;

    /*
     * Die case 2 ist Aufruf der Methode ,die nach Erscheinungsdatum
     * gleich als das eingegeben Datum sucht
     */

    case 2:
      suchDatentraegerNachErschjahrGleich (s);
      break;

    /*
     * Die case 3 ist Aufruf der Methode , die nach Erscheinungsdatum
     * Grosser als das eingegeben Datum sucht
     */

    case 3:
      suchDatentraegerNachErschjahrGross (s);
      break;

    /*
     * Die case 4 ist Aufruf der Methode , die nach Erscheinungsdatum
     * kleiner als das eingegeben Datum sucht
     */

    case 4:
      suchDatentraegerNachErschjahrKlein (s);
      break;

    /*
     * Die case 5 ist Aufruf der Methode , die nach Fachgebiet sucht
     */

    case 5:
      suchDatentraegerNachFachgebiet (s);
      break;

    /*
     * Die case 6 ist Aufruf der Methode , die nach Initial sucht
     */

    case 6:
      suchDatentraegerNachInitial (s);
      break;

    /*
     * Die case 7 ist Aufruf der Methode , die nach Sachgebiet sucht
     */

    case 7:
      suchDatentraegerNachSachgebiet (s);
      break;

    /*
     * Die case 8 ist Aufruf der Methode , die nach Schlagworte sucht
     */

    case 8:
      suchDatentraegerNachSchlagworte (s);
      break;

    /*
     * Die case demSpreichergrosse sucht 9 Aufruf der Methode , die nach
     */

    case 9:
      suchenDatentraegerNachSpeicherplatz (s);
      break;

    /*
     * Die case 10 ist Aufruf der Methode , die nach Stichworte sucht
     */

    case 10:
      suchDatentraegerNachStichworte (s);
      break;

    /*
     * Die case 11 ist Aufruf der Methode ,die nach Thema sucht
     */

    case 11:
      suchDatentraegerNachThema (s);
      break;

    /*
     * Die case 12 ist Aufruf der Methode ,die nach Titel sucht
     */

    case 12:
      suchDatentraegerNachTitel (s);
      break;

    default:
      break;

    }

  }


  /*
   * Die Methode liert ale basis informationen ueber ein Medium in einem
   * String .Die Methode nimmt ein Objekt Medium als parameter und gibt
   * ein String zurueck.
   */

  public String superString (Medium t)
  {
    String s = "\n ";
    s += "\nFach: ";
    s += t.gibFachgebiet ();
    s += " Sach: ";
    s += t.gibSachgebiet ();
    s += " \nThema: ";
    s += t.gibThema ();
    s += " Titel ";
    s += t.gibTitel ();
    s += " \nStichW: ";
    s += t.gibStichworteString ();
    s += " Erschnungsjahr: ";
    s += t.gibErscheinungsdatumString ();
    s += "\n Verlag: ";
    s += t.gibVerlag ().gibName ();

    return s;
  }


  /*
   * Die Methode ErgebnisToString wandelt eine Liste von gefundenen
   * Datentraeger in String um. und die Methode wird spaeter fuer die
   * Gui verwendet. Die Methode nimmt eine Liste von Objekten
   * Datentraeger .Und sie gibt ein String zurueck.
   */
  public String ErgebnisToString (List<Datentraeger> DatentraegerL)
  {
    String a = " ";

    for (Datentraeger Datentraeger : DatentraegerL)
    {
      a = "Datentraeger:\n ";
      a += Datentraeger.gibBeteiligteString ();
      a += superString (Datentraeger);
    }
    return a;
  }

}
